package com.taptech.doufu.ui.view;

import android.annotation.SuppressLint;
import android.content.Context;
import android.content.res.TypedArray;
import android.util.AttributeSet;
import android.util.Log;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.view.animation.LinearInterpolator;
import android.view.animation.RotateAnimation;
import android.widget.AbsListView;
import android.widget.AbsListView.OnScrollListener;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.ListView;
import android.widget.ProgressBar;
import android.widget.TextView;

import com.taptech.doufu.util.ScreenUtil;
import com.taptech.doufu.util.ScreenUtil2;
import com.taptech.doufu.util.TTLog;
import com.taptech.doufu.R;
import com.taptech.doufu.app.WeMediaApplication;
import com.taptech.doufu.constant.Constant;
import com.taptech.doufu.listener.FirstItemable;
import com.taptech.doufu.listener.ToUpOrDownable;
import com.taptech.doufu.util.AppUtil;
import com.taptech.doufu.util.DoufuUtils;
import com.taptech.doufu.net.httputils.HttpResponseObject;

import org.greenrobot.eventbus.EventBus;
import org.json.JSONObject;

import java.util.HashMap;
import java.util.Map;

import github.chenupt.dragtoplayout.AttachUtil;

/**
 * 下拉刷新控件
 *
 * @author liux (http://my.oschina.net/liux)
 * @version 1.0
 * @created 2012-3-21
 */
@SuppressLint({"Recycle", "NewApi"})
public class PullToRefreshListView extends ListView implements OnScrollListener {
    private float xDistance, yDistance, xLast, yLast;
    // 下拉刷新标志
    private final static int PULL_To_REFRESH = 0;
    // 松开刷新标志
    private final static int RELEASE_To_REFRESH = 1;
    // 正在刷新标志
    private final static int REFRESHING = 2;
    // 刷新完成标志
    private final static int DONE = 3;

    private int headerSpace = ScreenUtil2.dip2px(20);

    private LayoutInflater inflater;

    private int progressType, pullType;

    private Context mContext;
    protected LinearLayout headView, footView, spaceHeader;
    private TextView tipsTextview, footMore;
    private TextView lastUpdatedTextView;
    private ImageView arrowImageView, loadCompleteImg;
    private ProgressBar progressBar, footProgress;
    // 用来设置箭头图标动画效果
    private RotateAnimation animation;
    private RotateAnimation reverseAnimation;

    // 用于保证startY的值在一个完整的touch事件中只被记录一次
    private boolean isRecored;

    private int headContentHeight;
    private int headContentOriginalTopPadding;

    private int startY;
    public int firstItemIndex;
    private int currentScrollState;

    private int state;

    private boolean isBack, isFull;

    private boolean refreshable, loadmoreable;

    public OnLoadAndRefreshListener refreshListener;
    public OnLoadMoreListener loadMoreListener;

    public PullToRefreshListView(Context context) {
        super(context);
        init(context);
    }

    public PullToRefreshListView(Context context, AttributeSet attrs) {
        super(context, attrs);
        TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.PullToRefreshListView);
        progressType = a.getInt(R.styleable.PullToRefreshListView_progressType, 0);
        pullType = a.getInt(R.styleable.PullToRefreshListView_pullType, 0);
        init(context);
    }

    public PullToRefreshListView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.PullToRefreshListView);
        progressType = a.getInt(R.styleable.PullToRefreshListView_progressType, 0);
        pullType = a.getInt(R.styleable.PullToRefreshListView_pullType, 0);
        init(context);
    }

    private void init(Context context) {
        this.mContext = context;
        // 设置滑动效果
        animation = new RotateAnimation(0, -180, RotateAnimation.RELATIVE_TO_SELF, 0.5f, RotateAnimation.RELATIVE_TO_SELF, 0.5f);
        animation.setInterpolator(new LinearInterpolator());
        animation.setDuration(100);
        animation.setFillAfter(true);

        reverseAnimation = new RotateAnimation(-180, 0, RotateAnimation.RELATIVE_TO_SELF, 0.5f, RotateAnimation.RELATIVE_TO_SELF, 0.5f);
        reverseAnimation.setInterpolator(new LinearInterpolator());
        reverseAnimation.setDuration(100);
        reverseAnimation.setFillAfter(true);

        inflater = LayoutInflater.from(context);
        headView = (LinearLayout) inflater.inflate(R.layout.pull_to_refresh_head, null);

        arrowImageView = (ImageView) headView.findViewById(R.id.head_arrowImageView);
        arrowImageView.setScaleType(ImageView.ScaleType.CENTER_INSIDE);
        arrowImageView.setImageLevel(1);
//        arrowImageView.setMinimumWidth(50);
//        arrowImageView.setMinimumHeight(50);
        progressBar = (ProgressBar) headView.findViewById(R.id.head_progressBar);

        tipsTextview = (TextView) headView.findViewById(R.id.head_tipsTextView);
        lastUpdatedTextView = (TextView) headView.findViewById(R.id.head_lastUpdatedTextView);

        headContentOriginalTopPadding = headView.getPaddingTop();

        measureView(headView);
        headContentHeight = headView.getMeasuredHeight();
        headView.invalidate();
        // System.out.println("初始高度："+headContentHeight);
        // System.out.println("初始TopPad："+headContentOriginalTopPadding);

        if (pullType == 1) {
            spaceHeader = new LinearLayout(getContext());
            spaceHeader.setLayoutParams(new LayoutParams(LayoutParams.MATCH_PARENT, ScreenUtil2.dip2px(202)));
            spaceHeader.setAlpha(1);
            spaceHeader.setGravity(Gravity.BOTTOM | Gravity.CENTER_HORIZONTAL);
            addHeaderView(spaceHeader);
        }
        if (pullType == 2) {
            spaceHeader = new LinearLayout(getContext());
            //            spaceHeader.setLayoutParams(new LayoutParams(LayoutParams.MATCH_PARENT, ScreenUtil2.dip2px(145)));
            spaceHeader.setLayoutParams(new LayoutParams(LayoutParams.MATCH_PARENT, ScreenUtil2.dip2px(145)));
            spaceHeader.setAlpha(1);
            spaceHeader.setGravity(Gravity.BOTTOM | Gravity.CENTER_HORIZONTAL);
            addHeaderView(spaceHeader);
        }

        headView.setPadding(headView.getPaddingLeft(), -1 * headContentHeight, headView.getPaddingRight(), headView.getPaddingBottom());
        addHeaderView(headView);
        setOnScrollListener(this);
        setOnScrollListener(this);
    }

    private int lastKeepPos = 0;

    @Override
    public void onScroll(AbsListView view, int firstVisiableItem, int visibleItemCount, int totalItemCount) {
        firstItemIndex = firstVisiableItem;
        if (firstItemable != null) {
            firstItemable.getFirstPos(firstVisiableItem);
        }

        try {
            if (0 != firstVisiableItem) {
                if (lastKeepPos != firstVisiableItem) {
                    if (upOrDownable != null) {
                        if (firstVisiableItem > lastKeepPos) {
                            //向下滑动
                            upOrDownable.moveToUp();
                        } else {
                            //向上滑动
                            upOrDownable.moveToDown(firstVisiableItem);
                        }
                    }
                    lastKeepPos = firstVisiableItem;
                }
            }
            EventBus.getDefault().post(AttachUtil.isAdapterViewAttach(view));

            if(getAdapter()==null){
                return;
            }
            //listview当前在屏幕可见的第一个item，也就是firstVisibleItem索引对应的item
            View firstVisibleChild=getChildAt(0);
            if(firstVisibleChild==null){
                return;
            }
            if(!mItemHeights.containsKey(firstVisiableItem)){
                //将每个item以 key:index, value:height 存入map
                mItemHeights.put(firstVisiableItem, firstVisibleChild.getHeight());
            }
            int scrollY=computeScrollY(firstVisiableItem, firstVisibleChild);
            if (onScrollYListener != null) {
                onScrollYListener.onScrollY(scrollY);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private Map<Integer, Integer> mItemHeights=new HashMap<>();
    private OnScrollYListener onScrollYListener;

    public void setOnScrollYListener(OnScrollYListener onScrollYListener) {
        this.onScrollYListener = onScrollYListener;
    }

    private int computeScrollY(int firstVisibleItem, View firstVisibleChild){
        int scrollY=0;
        int sum=0, count=0;
        for(int i=0; i<=firstVisibleItem; i++){
            Integer h=mItemHeights.get(i);
            //当快速滑动listview时，firstVisibleItem不是连续增长，ex 0,1,3,7....
            if(h==null){
                continue;
            }
            sum+=h;
            count++;
        }
        if(count==0){
            return 0;
        }
        //已经记录的item的高度的平均值
        int avarage=sum/count;
        //已记录的item高度总和+没有记录的item的高度总和
        scrollY=sum+avarage*(firstVisibleItem+1-count);
        //第一个item可能这时候还有一半在屏幕内，这时候要减去这个item在屏幕内部分的高度
        scrollY-=firstVisibleChild.getBottom();
        return scrollY;
    }

    /**
     * 垂直方向滚动距离
     */
    public interface OnScrollYListener{
        void onScrollY(int scrolledY);
    }

    /**
     * 滚动到列表底部的监听
     *
     * @author Diaobao22
     */

    public interface OnScrollToBottomListener {
        void OnScrollToBottom();
    }

    protected OnScrollToBottomListener onScrollToBottomListener;

    public void setOnScrollToBottomListener(OnScrollToBottomListener onScrollToBottomListener) {
        this.onScrollToBottomListener = onScrollToBottomListener;
    }


    public void setMoveListener(ToUpOrDownable upOrDownable) {
        this.upOrDownable = upOrDownable;
    }

    public void setFirstItemChangListener(FirstItemable firstItemable) {
        this.firstItemable = firstItemable;
    }

    public ToUpOrDownable upOrDownable = null;
    public FirstItemable firstItemable = null;

    int lastRecordFlingPos = -999;
    private int lvIndex = 0;
    private IOnScrollState iOnScrollState;

    public void setOnScrollStateListent(IOnScrollState iOnScrollState) {
        this.iOnScrollState = iOnScrollState;
    }

    public void onScrollStateChanged(AbsListView view, int scrollState) {
        if (this.iOnScrollState != null) {
            this.iOnScrollState.onState(scrollState);
        }
        this.setCurrentScrollState(scrollState);
        if (this.isLoadmoreable()) {
            // 判断是否滚动到底部
            boolean scrollEnd = false;
            try {
                if (view.getPositionForView(this.getFootView()) == view.getLastVisiblePosition()) {
                    scrollEnd = true;
                }
            } catch (Exception e) {
                scrollEnd = false;
            }
            TTLog.s("this.isFull()==" + this.isFull());
            if (scrollEnd && !this.isFull()) {
                this.loadMore();
                // 对外接口
                if (this.onScrollToBottomListener != null) {
                    this.onScrollToBottomListener.OnScrollToBottom();
                }
            }
        }
    }

    public boolean onTouchEvent(MotionEvent event) {
        try {

            if (refreshable) {
                switch (event.getAction()) {

                    case MotionEvent.ACTION_DOWN:
                        if (firstItemIndex == 0 && !isRecored) {
                            startY = (int) event.getY();
                            isRecored = true;
                            // System.out.println("当前-按下高度-ACTION_DOWN-Y："+startY);
                        }
                        break;

                    case MotionEvent.ACTION_CANCEL:// 失去焦点&取消动作
                    case MotionEvent.ACTION_UP:
                        if (state != REFRESHING) {
                            if (state == DONE) {
                                // System.out.println("当前-抬起-ACTION_UP：DONE什么都不做");
                            } else if (state == PULL_To_REFRESH) {
                                state = DONE;
                                changeHeaderViewByState();
                                // System.out.println("当前-抬起-ACTION_UP：PULL_To_REFRESH-->DONE-由下拉刷新状态到刷新完成状态");
                            } else if (state == RELEASE_To_REFRESH) {
                                state = REFRESHING;
                                changeHeaderViewByState();
                                onRefresh();
                                // System.out.println("当前-抬起-ACTION_UP：RELEASE_To_REFRESH-->REFRESHING-由松开刷新状态，到刷新完成状态");
                            }
                        }

                        isRecored = false;
                        isBack = false;

                        break;

                    case MotionEvent.ACTION_MOVE:
                        int tempY = (int) event.getY();
                        // System.out.println("当前-滑动-ACTION_MOVE Y："+tempY);
                        if (!isRecored && firstItemIndex == 0) {
                            // System.out.println("当前-滑动-记录拖拽时的位置 Y："+tempY);
                            isRecored = true;
                            startY = tempY;
                        }
                        if (state != REFRESHING && isRecored) {
                            // 可以松开刷新了
                            if (state == RELEASE_To_REFRESH) {
                                // 往上推，推到屏幕足够掩盖head的程度，但还没有全部掩盖
                                if ((tempY - startY < headContentHeight + headerSpace) && (tempY - startY) > 0) {
                                    state = PULL_To_REFRESH;
                                    changeHeaderViewByState();
                                    // System.out.println("当前-滑动-ACTION_MOVE：RELEASE_To_REFRESH--》PULL_To_REFRESH-由松开刷新状态转变到下拉刷新状态");
                                }
                                // 一下子推到顶
                                else if (tempY - startY <= 0) {
                                    state = DONE;
                                    changeHeaderViewByState();
                                    // System.out.println("当前-滑动-ACTION_MOVE：RELEASE_To_REFRESH--》DONE-由松开刷新状态转变到done状态");
                                }
                                // 往下拉，或者还没有上推到屏幕顶部掩盖head
                                else {
                                    // 不用进行特别的操作，只用更新paddingTop的值就行了
                                }
                            }
                            // 还没有到达显示松开刷新的时候,DONE或者是PULL_To_REFRESH状态
                            else if (state == PULL_To_REFRESH) {
                                // 下拉到可以进入RELEASE_TO_REFRESH的状态
                                if (tempY - startY >= headContentHeight + headerSpace && currentScrollState == SCROLL_STATE_TOUCH_SCROLL) {
                                    state = RELEASE_To_REFRESH;
                                    isBack = true;
                                    changeHeaderViewByState();
                                    // System.out.println("当前-滑动-PULL_To_REFRESH--》RELEASE_To_REFRESH-由done或者下拉刷新状态转变到松开刷新");
                                }
                                // 上推到顶了
                                else if (tempY - startY <= 0) {
                                    state = DONE;
                                    changeHeaderViewByState();
                                    // System.out.println("当前-滑动-PULL_To_REFRESH--》DONE-由Done或者下拉刷新状态转变到done状态");
                                }
                            }
                            // done状态下
                            else if (state == DONE) {
                                if (tempY - startY > 0 && getFirstVisiblePosition() == 0) {
                                    state = PULL_To_REFRESH;
                                    changeHeaderViewByState();
                                    // System.out.println("当前-滑动-DONE--》PULL_To_REFRESH-由done状态转变到下拉刷新状态");
                                }
                            }

                            // 更新headView的size
                            if (state == PULL_To_REFRESH) {
                                int topPadding = (int) ((-1 * headContentHeight + (tempY - startY)));
                                headView.setPadding(headView.getPaddingLeft(), topPadding, headView.getPaddingRight(), headView.getPaddingBottom());
                                headView.invalidate();
                                // System.out.println("当前-下拉刷新PULL_To_REFRESH-TopPad："+topPadding);
                            }

                            // 更新headView的paddingTop
                            if (state == RELEASE_To_REFRESH) {
                                int topPadding = (int) ((tempY - startY - headContentHeight));
                                if (topPadding < ScreenUtil.dip2px(mContext, 100)) {
                                    headView.setPadding(headView.getPaddingLeft(), topPadding, headView.getPaddingRight(), headView.getPaddingBottom());
                                    headView.invalidate();
                                }
                                // System.out.println("当前-释放刷新RELEASE_To_REFRESH-TopPad："+topPadding);
                            }
                        }
                        break;
                }
            }
            return super.onTouchEvent(event);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    // 当状态改变时候，调用该方法，以更新界面
    private void changeHeaderViewByState() {
        switch (state) {
            case RELEASE_To_REFRESH:

                arrowImageView.setVisibility(View.VISIBLE);
                progressBar.setVisibility(View.GONE);
                tipsTextview.setVisibility(View.VISIBLE);
                lastUpdatedTextView.setVisibility(View.VISIBLE);

                arrowImageView.clearAnimation();
                arrowImageView.startAnimation(animation);

                tipsTextview.setText(R.string.pull_to_refresh_release_label);

                // Log.v(TAG, "当前状态，松开刷新");
                break;
            case PULL_To_REFRESH:

                progressBar.setVisibility(View.GONE);
                tipsTextview.setVisibility(View.VISIBLE);
                lastUpdatedTextView.setVisibility(View.VISIBLE);
                arrowImageView.clearAnimation();
                arrowImageView.setVisibility(View.VISIBLE);
                if (isBack) {
                    isBack = false;
                    arrowImageView.clearAnimation();
                    arrowImageView.startAnimation(reverseAnimation);
                }
                tipsTextview.setText(R.string.pull_to_refresh_pull_label);

                // Log.v(TAG, "当前状态，下拉刷新");
                break;

            case REFRESHING:
                // System.out.println("刷新REFRESHING-TopPad："+headContentOriginalTopPadding);
                headView.setPadding(headView.getPaddingLeft(), headContentOriginalTopPadding, headView.getPaddingRight(), headView.getPaddingBottom());
                headView.invalidate();

                progressBar.setVisibility(View.VISIBLE);
                arrowImageView.clearAnimation();
                arrowImageView.setVisibility(View.GONE);
                tipsTextview.setText(Constant.loadings[((int) (Math.random() * Constant.loadings.length))]);
                tipsTextview.setTextSize(12);
                //tipsTextview.setVisibility(GONE);
                TTLog.d("tag", "tipsTextView display text is =============" + tipsTextview.getText().toString());
                lastUpdatedTextView.setVisibility(View.GONE);

                // Log.v(TAG, "当前状态,正在刷新...");
                break;
            case DONE:
                // System.out.println("完成DONE-TopPad："+(-1 * headContentHeight));
                headView.setPadding(headView.getPaddingLeft(), -1 * headContentHeight, headView.getPaddingRight(), headView.getPaddingBottom());
                headView.invalidate();

                progressBar.setVisibility(View.GONE);
                arrowImageView.clearAnimation();
                // 此处更换图标
                arrowImageView.setImageResource(R.drawable.pulltorefresh_down_arrow);

                tipsTextview.setText(R.string.pull_to_refresh_pull_label);
                lastUpdatedTextView.setVisibility(View.VISIBLE);

                // Log.v(TAG, "当前状态，done");
                break;
        }
    }

    // 点击刷新
    public void clickRefresh() {
        setSelection(0);
        state = REFRESHING;
        changeHeaderViewByState();
        onRefresh();
    }

    public void setOnLoadAndRefreshListener(OnLoadAndRefreshListener refreshListener) {
        this.refreshListener = refreshListener;
    }

    public interface IOnScrollState{
        void onState(int state);
    }

    public interface OnLoadAndRefreshListener {
        public void onRefresh();

        public void loadMore();
    }

    public interface OnLoadMoreListener {
        void loadMore();
    }

    public void setOnLoadMoreListener(OnLoadMoreListener loadMoreListener){
        this.loadMoreListener = loadMoreListener;
    }

    public void onRefreshComplete(String update) {
        lastUpdatedTextView.setText(update);
        onRefreshComplete();
    }

    public void onRefreshComplete() {
        state = DONE;
        // footMore.setVisibility(View.GONE);
        changeHeaderViewByState();
    }

    private void onRefresh() {
        if (refreshListener != null) {
            refreshListener.onRefresh();
            if (!AppUtil.IsNetworkConnected(mContext)) {
                DoufuUtils.netWorkErrorToast(mContext);
            }
        }
    }

    // 计算headView的width及height值
    private void measureView(View child) {
        ViewGroup.LayoutParams p = child.getLayoutParams();
        if (p == null) {
            p = new ViewGroup.LayoutParams(ViewGroup.LayoutParams.FILL_PARENT, ViewGroup.LayoutParams.FILL_PARENT);
        }
        int childWidthSpec = ViewGroup.getChildMeasureSpec(0, 0 + 0, p.width);
        int lpHeight = p.height;
        int childHeightSpec;
        if (lpHeight > 0) {
            childHeightSpec = MeasureSpec.makeMeasureSpec(lpHeight, MeasureSpec.EXACTLY);
        } else {
            childHeightSpec = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);
        }
        child.measure(childWidthSpec, childHeightSpec);
    }

    public boolean isRefreshable() {
        return refreshable;
    }

    public void setRefreshable(boolean refreshable) {
        this.refreshable = refreshable;
    }

    public boolean isLoadmoreable() {
        return loadmoreable;
    }

    public void setLoadmoreable(boolean loadmoreable) {
        if (loadmoreable && footView == null) {
            footView = (LinearLayout) inflater.inflate(R.layout.listview_footer, null);
            footMore = (TextView) footView.findViewById(R.id.listview_foot_more);
            loadCompleteImg = (ImageView) footView.findViewById(R.id.listview_foot_load_complete);
            loadCompleteImg.setVisibility(View.GONE);
            // footView.findViewById(R.id.foot_view_lien).setVisibility(View.VISIBLE);
            footProgress = (ProgressBar) footView.findViewById(R.id.listview_foot_progress);
            if (progressType == 1) {
                footProgress.setScrollBarStyle(R.style.loading_diaobao);
            }
            addFooterView(footView);
            this.setOnScrollListener(this);
        }
        this.loadmoreable = loadmoreable;
    }

    public void loadMore() {
        // 当前pageIndex
        if (refreshListener != null) {
            footView.setVisibility(View.VISIBLE);
            // 彩虹万岁，等等无罪
            footMore.setText(Constant.loadings[((int) (Math.random() * Constant.loadings.length))]);
            footMore.setVisibility(View.VISIBLE);
            loadCompleteImg.setVisibility(View.GONE);
            footProgress.setVisibility(View.VISIBLE);
            refreshListener.loadMore();
            if (loadMoreListener != null) {
                loadMoreListener.loadMore();
            }
        }
    }

    public void loadMoreView() {
        if (footView != null && footMore != null && loadCompleteImg != null && footProgress != null) {
            // 当前pageIndex
            footView.setVisibility(View.VISIBLE);
            // 彩虹万岁，等等无罪
            //footMore.setText(Constant.loading);
            footMore.setText(Constant.loadings[((int) (Math.random() * Constant.loadings.length))]);
            footMore.setTextSize(12);
            footMore.setVisibility(View.VISIBLE);
            loadCompleteImg.setVisibility(View.GONE);
            footProgress.setVisibility(View.VISIBLE);
        }
    }

    public void loadMoreNoComplete() {
        if (footProgress != null)
            footProgress.setVisibility(View.VISIBLE);
        if (footMore != null) {
            // footMore.setText("已加载完了");
            footMore.setVisibility(View.VISIBLE);
            loadCompleteImg.setVisibility(View.GONE);
        }
    }

    public void loadMoreComplete() {
        if (isFull) {
            if (footProgress != null)
                footProgress.setVisibility(View.GONE);
            if (footMore != null) {
                // footMore.setText("已加载完了");
                footMore.setVisibility(View.GONE);
                loadCompleteImg.setVisibility(View.VISIBLE);
            }
        } else {
            if (footView != null) {
                footView.setVisibility(View.GONE);
            }
        }
    }

    public void loadMoreData() {
        if (footProgress != null)
            footProgress.setVisibility(View.GONE);
        if (footMore != null) {
            footMore.setText("上拉更多");
            footMore.setVisibility(View.VISIBLE);
            loadCompleteImg.setVisibility(View.GONE);
        }
    }

    public void loadMoreTimeout() {
        if (footProgress != null && footMore != null) {
            footProgress.setVisibility(View.GONE);
            footMore.setText(Constant.loadingFail);
            footMore.setVisibility(View.VISIBLE);
            loadCompleteImg.setVisibility(View.GONE);
            footView.setOnClickListener(new OnClickListener() {

                @Override
                public void onClick(View v) {
                    if (refreshListener != null) {
                        loadMore();
                        footView.setOnClickListener(null);
                    }
                }
            });
        }

    }

    public ImageView getLoadCompleteImg() {
        return loadCompleteImg;
    }

    public void setLoadCompleteImg(ImageView loadCompleteImg) {
        this.loadCompleteImg = loadCompleteImg;
    }

    public View getFootView() {
        return footView;
    }

    public TextView getFootMore() {
        return footMore;
    }

    public View getFootProgress() {
        return footProgress;
    }

    public boolean isFull() {
        return isFull;
    }

    public void setFull(boolean isFull) {
        this.isFull = isFull;
    }

    public int getCurrentScrollState() {
        return currentScrollState;
    }

    public void setCurrentScrollState(int currentScrollState) {
        this.currentScrollState = currentScrollState;
    }

    @Override
    protected void layoutChildren() {
        super.layoutChildren();
        setEnabled(true);
    }

    public int getHeaderSpace() {
        return headerSpace;
    }

    public void setHeaderSpace(int headerSpace) {
        this.headerSpace = headerSpace;
    }

    public LinearLayout getHeadView() {
        return headView;
    }

    public void setHeadView(LinearLayout headView) {
        this.headView = headView;
    }

    public LinearLayout getSpaceHeader() {
        return spaceHeader;
    }

    public void setSpaceHeader(LinearLayout spaceHeader) {
        this.spaceHeader = spaceHeader;
    }

    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        switch (ev.getAction()) {
            case MotionEvent.ACTION_DOWN:
                xDistance = yDistance = 0f;
                xLast = ev.getX();
                yLast = ev.getY();
                break;
            case MotionEvent.ACTION_MOVE:
                final float curX = ev.getX();
                final float curY = ev.getY();

                xDistance += Math.abs(curX - xLast);
                yDistance += Math.abs(curY - yLast);
                xLast = curX;
                yLast = curY;

                if (xDistance > yDistance) {
                    return false;
                }
        }

        return super.onInterceptTouchEvent(ev);
    }


    public void changeBgView(){
        if(WeMediaApplication.getInstance().isDayNightMode_Night){
            darkBgView();
        }else {
            dayBgView();
        }
    }
    private void dayBgView(){
        if(tipsTextview != null){
            tipsTextview.setTextColor(getResources().getColor(R.color.black));
            lastUpdatedTextView.setTextColor(getResources().getColor(R.color.black));
            progressBar.setAlpha(1.0f);
        }

        if(footMore != null) {
            footMore.setTextColor(getResources().getColor(R.color.text_color_33));
            footProgress.setAlpha(Constant.imagViewAlpha);
        }
    }
    private void darkBgView(){
        if(tipsTextview != null) {
            tipsTextview.setTextColor(getResources().getColor(R.color.text_dark));
            lastUpdatedTextView.setTextColor(getResources().getColor(R.color.text_dark));
            progressBar.setAlpha(1.0f);
        }
        if(footMore != null){
            footMore.setTextColor(getResources().getColor(R.color.text_dark));
            footProgress.setAlpha(Constant.imagViewAlpha);
        }

    }
}
